use crossterm::ansi_support;
use std::env;
use std::io::{IsTerminal, stdout};
use supports_color::Stream;
use sysinfo::System;

//************************ deprecated ************************

//============= 检测是否是 windows cmd
pub fn my_is_running_in_cmd_b1() -> bool {
    let in_cmd = if cfg!(windows) {
        // 检查 cmd 特有的环境变量
        env::var("PROMPT").is_ok()  // cmd 设置此变量
        // powershell 和 nushell 也会设置此变量
        && env::var("COMSPEC").map_or(false, |v| v.ends_with("cmd.exe")) // 命令行解释器路径
    } else {
        false // 非 Windows 系统直接返回 false
    };

    if in_cmd {
        println!("I'm running in cmd");
    } else {
        println!("I'm not running in cmd");
    }
    in_cmd
}

// ============================ 检测是否支持 ansi 颜色; 但不支持 256 色
pub fn my_is_support_ansi_b1() -> bool {
    //let stdout = stdout();
    if ansi_support::supports_ansi() {
        println!("终端支持ANSI颜色！");
        // 输出带颜色的文本
        print!("\x1b[31m红色文本\x1b[0m\n");
        return true;
    } else {
        println!("终端不支持ANSI颜色。");
        return false;
    }
}

//============= 检测是否 支持颜色; 测试结果不准; windows terminal 显示 只支持 support.has_basic
pub fn my_is_support_color_256_b1() -> bool {
    if let Some(support) = supports_color::on(Stream::Stdout) {
        if support.has_16m {
            println!("16 million (RGB) colors are supported");
            return true;
        } else if support.has_256 {
            println!("256-bit colors are supported.");
            return true;
        } else if support.has_basic {
            println!("Only basic ANSI colors are supported.");
            return false;
        }
    } else {
        println!("No color support.");
        return false;
    }

    return false;
}

//============= 检测是否 支持颜色, backup
pub fn my_is_support_color_b1() -> bool {
    // 检查是否在终端中
    if !stdout().is_terminal() {
        return false;
    }

    // 处理 Windows 特殊情况
    if cfg!(windows) {
        // 检查是否在传统 cmd 中（Windows 10+ 支持颜色，但需特殊处理）
        if env::var("TERM_PROGRAM").is_err() && env::var("ANSICON").is_err() && env::var("PROMPT").is_ok() {
            // 传统 cmd 且未启用 ANSI 支持
            return false;
        }
    } else {
        // 类 Unix 系统检查 TERM 变量
        if let Ok(term) = env::var("TERM") {
            return term != "dumb";
        }
        return false;
    }

    true
}

//============= 检测是否是 windows cmd;
// 在 explorer 中运行 cargo run 时, 父进程名称为 explorer.exe, 不能准确判断
pub fn my_is_running_in_cmd_b2() -> bool {
    if !cfg!(windows) {
        println!("Not running on Windows, so not in cmd.exe.");
        return false;
    }
    let system = System::new_all();

    let ret = sysinfo::get_current_pid()
        // 获取当前进程的 PID
        .map_or_else(
            |e| {
                println!("Error getting current PID: {e}");
                None
            },
            |cur_pid| {
                println!("This process PID: {}", cur_pid);
                system.process(cur_pid)
            },
        )
        // 获取当前进程
        .map_or_else(
            || {
                println!("Error getting current process");
                None
            },
            |process| {
                println!("This process name: {:?}", process.name());
                process.parent() // 获取父进程 pid
            },
        )
        // 获取父进程
        .map_or_else(
            || {
                println!("Error getting parent pid");
                None
            },
            |prt_pid| system.process(prt_pid),
        )
        // 获取父进程名称
        .map_or_else(
            || {
                println!("Error getting parent process");
                None
            },
            |prt_proc| {
                let prt_name = prt_proc.name();
                // println!("Parent process name: {:?}", prt_name);
                let prt_name = prt_name.to_ascii_lowercase();
                let prt_name = prt_name.to_str();
                if prt_name.is_none() {
                    println!("Parent process name is not valid UTF-8.");
                    return None;
                }
                let prt_name = prt_name.unwrap();
                match prt_name {
                    #[cfg(any())]
                    "cargo.exe" => prt_proc.parent().and_then(|gprt_pid| {
                        system.process(gprt_pid).and_then(|gprt_p| {
                            gprt_p.name().to_ascii_lowercase().to_str().map(|name| match name {
                                "cmd.exe" => {
                                    println!("Running in cmd.exe via cargo.");
                                    true
                                }
                                _ => {
                                    println!("Not running in cmd.exe, grand parent process is: {name}");
                                    false
                                }
                            })
                        })
                    }),
                    "cmd.exe" => {
                        println!("Running in cmd.exe.");
                        Some(true)
                    }
                    _ => {
                        println!("Not running in cmd.exe, parent process is: {prt_name:?}");
                        Some(false)
                    }
                }
            },
        )
        .unwrap_or_else(|| {
            println!("Parent process not found.");
            false
        });

    return ret;
}
